#import "XUser.h"


// 性别
NSInteger const SEX_UNKNOW                           = -1;
NSInteger const SEX_MALE                             = 1;
NSInteger const SEX_FEMALE                           = 0;


NSString * const KEY_WIFIONLY                        = @"wifi-only";
NSString * const KEY_OPENJPUSH                       = @"open-jpush";


static NSString * const KEY_CITYID                   = @"city-id";                 // 城市ID
static NSString * const KEY_CITYCODE                 = @"city-code";               // 城市编码
static NSString * const KEY_CITYNAME                 = @"city-name";               // 城市名
static NSString * const KEY_CITYPINCAP               = @"city-pincap";             // 城市名拼音首字母
static NSString * const KEY_CITYGEO                  = @"city-geo";                // 城市
static NSString * const KEY_PROVSHORTNAME            = @"province-shortname";
static NSString * const KEY_CITYBAIDUCODE            = @"city-baiducode";          // 城市百度编码

static NSString * const KEY_USERID                   = @"user-id";
static NSString * const KEY_USERPWD                  = @"user-password";
static NSString * const KEY_USERNAME                 = @"user-name";
static NSString * const KEY_AUTHORITY                = @"user-authority";
static NSString * const KEY_USERREALNAME             = @"user-realname";
static NSString * const KEY_SEX                      = @"sex";

static NSString * const KEY_PHONENUM                 = @"phone-number";
static NSString * const KEY_EMAIL                    = @"email";
static NSString * const KEY_INTEGRAL                 = @"integral";
static NSString * const KEY_LOGINNUM                 = @"login_num";
static NSString * const KEY_LASTLOGINTIME            = @"login_time";
static NSString * const KEY_REGISTERTIME             = @"register_time";

static NSString * const KEY_ACCOUNT                  = @"account";
static NSString * const KEY_PASSWORD                 = @"password";
static NSString * const KEY_SAVEPASSWORD             = @"save-password";
static NSString * const KEY_AUTOLOGIN                = @"autologin";

static NSString * const FILE_USERCUSTOMDATA          = @"UserUtil.plist";

static NSString * const DEFAULT_CITY_ID              = @"A6843AC209694942B3D7C341F5ADB292";
static NSString * const DEFAULT_CITY_NAME            = @"珠海";
static NSString * const DEFAULT_CITY_CODE            = @"0756";
static NSString * const DEFAULT_CITY_BAIDUCODE       = @"140";
static NSString * const DEFAULT_CITY_PROVSHORTNAME   = @"粤";
static NSString * const DEFAULT_CITY_GEO             = @"113.552724,22.255899";
static NSString * const DEFAULT_CITY_PINCAP          = @"zhs";

static NSString * const KEY_LOC_CITY                 = @"LOCCITY";
NSString *const KEY_LOC_LAT                          = @"LOCLAT";
NSString *const KEY_LOC_LON                          = @"LOCLON";

@implementation XUser



#pragma mark 用户信息
/**
 * 获取当前用户ID
 * @result                           NSInteger 类型，用户ID，若没有设置的话，返回0
 */
+ (NSString *)userID {
    return [XUser stringForKey:KEY_USERID];
}


/**
 * 保存当前用户ID
 * @param   userID                   NSInteger 类型，用户ID
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setUserID:(NSString *)userID {
    return [XUser setString:userID forKey:KEY_USERID];
}


/**
 * 获取当前用户密码
 * @result                           用户密码，若没有设置的话，返回0
 */
+ (NSString *)userPwd {
    return [XUser stringForKey:KEY_USERPWD];
}


/**
 * 保存当前用户密码
 * @param   userPwd                  用户密码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setUserPwd:(NSString *)userPwd {
    return [XUser setString:userPwd forKey:KEY_USERPWD];
}


/**
 * 获取当前用户名
 * @result                           NSString 类型，用户名
 */
+ (NSString*)userName {
    return [XUser stringForKey:KEY_USERNAME];
}


/**
 * 保存当前用户名
 * @param    userName                NSString 类型，用户名
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setUserName:(NSString*)userName {
    return [XUser setString:userName forKey:KEY_USERNAME];
}


/**
 * 获取当前用户名
 * @result                           NSString 类型，用户名
 */
+ (NSString*)authority {
    return [XUser stringForKey:KEY_AUTHORITY];
}


/**
 * 保存当前用户名
 * @param    userName                NSString 类型，用户名
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setAuthority:(NSString *)authority {
    return [XUser setString:authority forKey:KEY_AUTHORITY];
}


/**
 * 获取当前用户真实姓名
 * @result                           NSString 类型，用户真实姓名
 */
+ (NSString*)userRealName {
    return [XUser stringForKey:KEY_USERREALNAME];
}


/**
 * 保存用户的真实姓名
 * @param    realName                NSString 类型，用户真实姓名
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setUserRealName:(NSString*)realName {
    return [XUser setString:realName forKey:KEY_USERREALNAME];
}


/**
 * 性别
 * @result                           返回用户性别：SEX_MALE 男性，SEX_FEMALE 女性，SEX_UNKNOW 未知
 */
+ (NSInteger)sex {
    return [XUser integerForKey:KEY_SEX];
}


/**
 * 性别
 * @param   sex                      NSInteger 类型，用户的性别，若不为 SEX_MALE、SEX_FEMALE 则全为：SEX_UNKNOW
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setSex:(NSInteger)sex {
    NSInteger nSex = sex;
    if (nSex != SEX_MALE && nSex != SEX_FEMALE) {
        nSex = SEX_UNKNOW;
    }
    return [XUser setInteger:nSex forKey:KEY_SEX];
}


/**
 * 获取当前用户手机号码
 * @result                           NSString 类型，用户手机号码
 */
+ (NSString*)phoneNum {
    return [XUser stringForKey:KEY_PHONENUM];
}


/**
 * 保存用户的手机号码
 * @param    phoneNum                NSString 类型，用户手机号码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setPhoneNum:(NSString*)phoneNum {
    // 验证有效性
    if (nil == phoneNum || phoneNum == (id) [NSNull null] || phoneNum.length == 0) {
        // 设置为 nil 时，相当于清空当前设置
        return [XUser removeObjectForKey:KEY_PHONENUM];
    }
    else {
        // 设置有值时，必须判断是否为电话号码
        NSCharacterSet *cs = [NSCharacterSet characterSetWithCharactersInString:@"0123456789-"];
        NSString *strFilter = [[phoneNum componentsSeparatedByCharactersInSet:cs] componentsJoinedByString:@""];
        // 判断电话号码中是否有横杠以外的字符
        if (strFilter.length > 0) {
            NSLog(@"输入的电话号码不符合电话号码的规则，无法保存!");
            return FALSE;
        }
        // 清理掉电话号码当中的横杠
        NSString *strPhoneNum = [[phoneNum componentsSeparatedByString:@"-"] componentsJoinedByString:@""];
        // 判断字符个数是否足够
        if (strPhoneNum.length != 11) {
            NSLog(@"输入的电话号码不符合电话号码的规则，无法保存!");
            return FALSE;
        }
        // 判断电话号码的前缀是否符合规则
        if (![strPhoneNum hasPrefix:@"1"]) {    // 松动的判断，紧要求以 1 开头
            NSLog(@"输入的电话号码不符合电话号码的规则，无法保存!");
            return FALSE;
        }
        return [XUser setString:strPhoneNum forKey:KEY_PHONENUM];
    }
}


/**
 * 获取当前用户邮箱
 * @result                           NSString 类型，用户邮箱
 */
+ (NSString*)email {
    return [XUser stringForKey:KEY_EMAIL];
}


/**
 * 保存用户的邮箱
 * @param    email                   NSString 类型，用户邮箱
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setEmail:(NSString*)email {
    // 验证有效性
    if (nil == email || email == (id) [NSNull null] || email.length == 0) {
        // 设置为 nil 时，相当于清空当前设置
        return [XUser removeObjectForKey:KEY_EMAIL];
    }
    else {
        // 设置有值时，必须判断是否为电子邮箱
        NSRange range = [email rangeOfString:@"@"];
        
        // 判断电话号码中是否有横杠以外的字符
        if (range.length == 0) {
            NSLog(@"输入的邮箱地址不符合规则，无法保存!");
            return FALSE;
        }
        
        return [XUser setString:email forKey:KEY_EMAIL];
    }
}


/**
 * 积分
 * @result                           返回用户积分
 */
+ (NSInteger)integral {
    return [XUser integerForKey:KEY_INTEGRAL];
}


/**
 * 设置积分
 * @param   integral                 NSInteger 类型，用户的积分
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setIntegral:(NSInteger)integral {
    return [XUser setInteger:integral > 0 ? integral : 0 forKey:KEY_INTEGRAL];
}


/**
 * 获取用户登录次数
 * @result                           返回用户登录次数
 */
+ (NSInteger)loginNum {
    return [XUser integerForKey:KEY_LOGINNUM];
}


/**
 * 设置用户登录次数
 * @param   loginNum                 NSInteger 类型，用户的登录次数
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setLoginNum:(NSInteger)loginNum {
    return [XUser setInteger:loginNum > 0 ? loginNum : 0 forKey:KEY_LOGINNUM];
}


/**
 * 获取当前用户注册时间
 * @result                           NSString 类型，用户注册时间
 */
+ (NSString*)lastLoginTime {
    return [XUser stringForKey:KEY_LASTLOGINTIME];
}


/**
 * 保存用户的用户注册时间
 * @param    lastLoginTime           NSString 类型，用户注册时间
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setLastLoginTime:(NSString*)lastLogin {
    return [XUser setString:lastLogin forKey:KEY_LASTLOGINTIME];
}


/**
 * 获取当前用户注册时间
 * @result                           NSString 类型，用户注册时间
 */
+ (NSString*)registerTime {
    return [XUser stringForKey:KEY_REGISTERTIME];
}


/**
 * 保存用户的用户注册时间
 * @param    registerTime            NSString 类型，用户注册时间
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setRegisterTime:(NSString*)registerTime {
    return [XUser setString:registerTime forKey:KEY_REGISTERTIME];
}


/**
 * 获取当前城市ID
 * @result                           NSString 类型，城市ID
 */
+ (NSString*)cityID {
    NSString *strCityID = [XUser stringForKey:KEY_CITYID];
    return strCityID ? strCityID : DEFAULT_CITY_ID;
}


/**
 * 保存当前城市ID
 * @param    cityID                  NSString 类型，城市ID
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setCityID:(NSString*)cityID {
    return [XUser setString:cityID forKey:KEY_CITYID];
}


/**
 * 获取当前城市编码
 * @result                           NSString 类型，城市编码
 */
+ (NSString*)cityCode {
    NSString *strCityCode = [XUser stringForKey:KEY_CITYCODE];
    return strCityCode ? strCityCode : DEFAULT_CITY_CODE;
}


/**
 * 保存当前城市编码
 * @param    cityCode                NSString 类型，城市编码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setCityCode:(NSString*)cityCode {
    return [XUser setString:cityCode forKey:KEY_CITYCODE];
}

/**
 * 保存当前城市百度编码
 * @param    cityCode                NSString 类型，城市百度编码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setBaiduCode:(NSString*)baiduCode {
    return [XUser setString:baiduCode forKey:KEY_CITYBAIDUCODE];
}

/**
 * 获取当前城市百度编码
 * @result                           NSString 类型，城市百度编码
 */
+ (NSString*)baiduCode {
    NSString *strBaiduCode = [XUser stringForKey:KEY_CITYBAIDUCODE];
    return strBaiduCode ? strBaiduCode : DEFAULT_CITY_BAIDUCODE;
}

/**
 * 获取当前城市名称
 * @result                           NSString 类型，城市名称
 */
+ (NSString*)cityName {
    NSString *strCityName = [XUser stringForKey:KEY_CITYNAME];
    return strCityName ? strCityName : DEFAULT_CITY_NAME;
}


/**
 * 保存当前城市名称
 * @param    cityName                NSString 类型，城市名称
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setCityName:(NSString*)cityName {
    return [XUser setString:cityName forKey:KEY_CITYNAME];
}


/**
 * 获取当前城市名称拼音首字母
 * @result                           NSString 类型，城市名称拼音首字母
 */
+ (NSString*)cityNamePinCap {
    NSString *strCityNamePinCap = [XUser stringForKey:KEY_CITYPINCAP];
    return strCityNamePinCap ? strCityNamePinCap : DEFAULT_CITY_PINCAP;
}


/**
 * 保存当前城市名称拼音首字母
 * @param    cityNamePinCap          NSString 类型，城市名称拼音首字母
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setCityNamePinCap:(NSString*)cityNamePinCap {
    return [XUser setString:cityNamePinCap forKey:KEY_CITYPINCAP];
}


/**
 * 获取当前城市坐标信息
 * @result                           CLLocationCoordinate2D 类型，城市坐标信息
 */
+ (CLLocationCoordinate2D)cityGEO {
    NSArray *arrGEO = (NSArray *) [XUser objectForKey:KEY_CITYGEO];
    if (nil == arrGEO) {
        NSArray *arrRet = [DEFAULT_CITY_GEO componentsSeparatedByString:@","];
        NSString *strLongitude = [arrRet objectAtIndex:0];
        NSString *strLatitude = [arrRet objectAtIndex:0];
        arrGEO = [NSArray arrayWithObjects:[NSNumber numberWithDouble:[strLongitude doubleValue]],
                  [NSNumber numberWithDouble:[strLatitude doubleValue]], nil];
    }
    NSNumber *numLongitude = [arrGEO objectAtIndex:0];
    NSNumber *numLatitude = [arrGEO objectAtIndex:1];
    CLLocationCoordinate2D geo;
    geo.longitude = [numLongitude doubleValue];
    geo.latitude = [numLatitude doubleValue];
    
    return geo;
}

/**
 *  保存当前定位到的位置所在的城市名
 */
+ (BOOL)setLocCity:(NSString*)city
{
    return [XUser setObject:city forKey:(NSString*)KEY_LOC_CITY];
}

/**
 *  获取定位到的位置所在的城市名
 */
+(NSString*)locCity
{
    NSString *strLocCity = [XUser stringForKey:KEY_LOC_CITY];
    return strLocCity ? strLocCity : DEFAULT_CITY_NAME;
}

/**
 * 保存当前城市坐标信息
 * @param   longitude                double 类型，城市坐标经度(x）
 * @param   latitude                 double 类型，城市坐标纬度(y）
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setCityGEOWithLongitude:(double)longitude andLatitude:(double)latitude {
    NSArray *arrGEO = [NSArray arrayWithObjects:[NSNumber numberWithDouble:longitude], [NSNumber numberWithDouble:latitude], nil];
    return [XUser setObject:arrGEO forKey:KEY_CITYGEO];
}


/**
 * 获取当前城市所属省份简称
 * @result                           NSString 类型，城市所属省份简称
 */
+ (NSString*)provShortName {
    NSString *strProvShortName = [XUser stringForKey:KEY_PROVSHORTNAME];
    return strProvShortName ? strProvShortName : DEFAULT_CITY_PROVSHORTNAME;
}


/**
 * 保存当前城市所属省份简称
 * @param    provShortName           NSString 类型，城市所属省份简称
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setProvShortName:(NSString*)provShortName {
    return [XUser setString:provShortName forKey:KEY_PROVSHORTNAME];
}


/**
 * 保存当前城市相关信息
 * @param    cityID                  NSString 类型，城市ID
 * @param    cityCode                NSString 类型，城市编码
 * @param    baiduCode               NSString 类型，城市百度编码
 * @param    cityName                NSString 类型，城市名称
 * @param    cityNamePinCap          NSString 类型，城市名称拼音首字母
 * @param    provShortName           NSString 类型，城市所属省份简称
 * @param    longitude               double 类型，城市坐标经度（x）
 * @param    latitude                double 类型，城市坐标纬度（y）
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)saveCityInfoWithID:(NSString *)cityID
                      code:(NSString *)cityCode
                 baiduCode:(NSString*)baiduCode
                      name:(NSString *)cityName
                    pinCap:(NSString *)pinCap
             provShortName:(NSString *)provShort
                 longitude:(double)longitude
                  latitude:(double)latitude; {
    // 保存信息
    BOOL bRet = [XUser setCityID:cityID];
    bRet &= [XUser setCityCode:cityCode];
    bRet &= [XUser setBaiduCode:baiduCode];
    bRet &= [XUser setCityName:cityName];
    bRet &= [XUser setCityNamePinCap:pinCap];
    bRet &= [XUser setProvShortName:provShort];
    bRet &= [XUser setCityGEOWithLongitude:longitude andLatitude:latitude];
    
    return bRet;
}


/**
 * 获取当前用户的登录帐号
 * @result                           NSString 类型，当前用户的登录帐号
 */
+ (NSString*)account {
    return [XUser stringForKey:KEY_ACCOUNT];
}


/**
 * 保存当前用户的登录帐号
 * @param    account                 NSString 类型，当前用户的登录帐号
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setAccount:(NSString*)account {
    return [XUser setString:account forKey:KEY_ACCOUNT];
}


/**
 * 获取当前用户的登录密码
 * @result                           NSString 类型，当前用户的登录密码
 */
+ (NSString*)password {
    return [XUser stringForKey:KEY_PASSWORD];
}


/**
 * 保存当前用户的登录密码
 * @param    password                NSString 类型，当前用户的登录密码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setPassword:(NSString*)password {
    return [XUser setString:password forKey:KEY_PASSWORD];
}


/**
 * 获取是否保存登录密码
 * @result                           BOOL 类型，是否保存登录密码
 */
+ (BOOL)savePassword {
    return [XUser boolForKey:KEY_SAVEPASSWORD];
}


/**
 * 保存是否保存登录密码
 * @param    savePwd                 BOOL 类型，是否保存登录密码
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setSavePassword:(BOOL)savePwd {
    return [XUser setBool:savePwd forKey:KEY_SAVEPASSWORD];
}


/**
 * 获取是否自动登录
 * @result                           BOOL 类型，是否自动登录
 */
+ (BOOL)autoLogin {
    return [XUser boolForKey:KEY_AUTOLOGIN];
}


/**
 * 保存是否自动登录
 * @param    autoLogin               BOOL 类型，是否自动登录
 * @result                           TRUE，标识保存成功，FALSE，标识保存失败
 */
+ (BOOL)setAutoLogin:(BOOL)autoLogin {
    return [XUser setBool:autoLogin forKey:KEY_AUTOLOGIN];
}


#pragma mark 用户自定义配置存取
// 根据Key值，获取标志位状态值(BOOL型信息）
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 数据类型
+ (BOOL)boolForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    id idObj = [dicCfg objectForKey:key];
    if (nil == idObj || [NSNull null] == (NSNull*)idObj) {
        NSLog(@"没有与关键字：%@ 对应的配置信息！", key);
        return FALSE;
    }
    else if ([idObj isKindOfClass:[NSNumber class]]) {
        NSNumber *num = (NSNumber*)idObj;
        return [num boolValue];
    }
    else if ([idObj isKindOfClass:[NSString class]]){
        NSString *str = (NSString*)idObj;
        return [str integerValue] == 0 ? FALSE : TRUE;
    }
    
    NSLog(@"关键字：%@ 对应的配置信息类型不为 BOOL 类型！", key);
    return FALSE;
}


// 根据Key值，写入相应的标志位状态值(BOOL型信息）
// @ flag                   BOOL 数据类型，对应的标志位值
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setBool:(BOOL)flag forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    [dicCfg setObject:[NSNumber numberWithBool:flag] forKey:key];
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


// 根据Key值，获取配置值(整型信息）
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 数据类型
+ (NSInteger)integerForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    id idObj = [dicCfg objectForKey:key];
    if (nil == idObj || [NSNull null] == (NSNull*)idObj) {
        NSLog(@"没有与关键字：%@ 对应的配置信息！", key);
        return 0;
    }
    else if ([idObj isKindOfClass:[NSNumber class]]) {
        NSNumber *num = (NSNumber*)idObj;
        return [num integerValue];
    }
    else if ([idObj isKindOfClass:[NSString class]]){
        NSString *str = (NSString*)idObj;
        return [str integerValue];
    }
    
    NSLog(@"关键字：%@ 对应的配置信息类型不为 NSInteger 类型！", key);
    return 0;
}


// 根据Key值，写入相应的配置值(整型信息）
// @ value                  NSInteger 数据类型
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setInteger:(NSInteger)value forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    [dicCfg setObject:[NSNumber numberWithInteger:value] forKey:key];
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


// 根据Key值，获取配置值(浮点信息）
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 数据类型
+ (float)floatForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    id idObj = [dicCfg objectForKey:key];
    if (nil == idObj || [NSNull null] == (NSNull*)idObj) {
        NSLog(@"没有与关键字：%@ 对应的配置信息！", key);
        return 0;
    }
    else if ([idObj isKindOfClass:[NSNumber class]]) {
        NSNumber *num = (NSNumber*)idObj;
        return [num floatValue];
    }
    else if ([idObj isKindOfClass:[NSString class]]){
        NSString *str = (NSString*)idObj;
        return [str floatValue];
    }
    
    NSLog(@"关键字：%@ 对应的配置信息类型不为 Float 类型！", key);
    return 0;
}


// 根据Key值，写入相应的配置值(浮点信息）
// @ value                  float 数据类型
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setFloat:(float)value forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    [dicCfg setObject:[NSNumber numberWithFloat:value] forKey:key];
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


// 根据Key值，获取配置值(双精度浮点信息）
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 数据类型
+ (double)doubleForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    id idObj = [dicCfg objectForKey:key];
    if (nil == idObj || [NSNull null] == (NSNull*)idObj) {
        NSLog(@"没有与关键字：%@ 对应的配置信息！", key);
        return 0;
    }
    else if ([idObj isKindOfClass:[NSNumber class]]) {
        NSNumber *num = (NSNumber*)idObj;
        return [num doubleValue];
    }
    else if ([idObj isKindOfClass:[NSString class]]){
        NSString *str = (NSString*)idObj;
        return [str doubleValue];
    }
    
    NSLog(@"关键字：%@ 对应的配置信息类型不为 Double 类型！", key);
    return 0;
}


// 根据Key值，写入相应的配置值(双精度浮点信息）
// @ value                  double 数据类型
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setDouble:(double)value forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    [dicCfg setObject:[NSNumber numberWithDouble:value] forKey:key];
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


// 根据Key值，获取配置值(字符串信息）
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 数据类型
+ (NSString*)stringForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    id idObj = [dicCfg objectForKey:key];
    if (nil == idObj || [NSNull null] == (NSNull*)idObj) {
        NSLog(@"没有与关键字：%@ 对应的配置信息！", key);
        return nil;
    }
    else if ([idObj isKindOfClass:[NSString class]]){
        NSString *str = (NSString*)idObj;
        return str;
    }
    
    NSLog(@"关键字：%@ 对应的配置信息类型不为 NSString 类型！", key);
    return nil;
}


// 根据Key值，写入相应的配置值(字符串信息）
// @ value                  NSString 数据类型
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setString:(NSString*)value forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    if (nil == value) {
        [dicCfg removeObjectForKey:key];
    }
    else {
        [dicCfg setObject:value forKey:key];
    }
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


// 根据Key值获取指定的数据
// @ key                    需要获取的数据的Key值，为AppDataKey类型(只支持既定的取值)
// @ 返回值                  id数据类型(可以为NSString，可以为NSNumber，可以为NSData等）
+ (id)objectForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSDictionary *dicCfg = [NSDictionary dictionaryWithContentsOfFile:strCfgFile];
    return [dicCfg objectForKey:key];
}


// 根据Key值，写入相应的Object对象(用于用户的自定义数据）
// @ obj                    id数据类型(可以为NSString，可以为NSNumber，可以为NSData等），需要记录的对象
// @ key                    需要获取的数据的Key值，为NSString类型
// @ 返回值                  BOOL 类型，YES表示设置成功，NO表示设置失败
+ (BOOL)setObject:(id)obj forKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    if (nil == obj) {
        [dicCfg removeObjectForKey:key];
    }
    else {
        [dicCfg setObject:obj forKey:key];
    }
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


/**
 * 根据Key值，移除相应的Object对象(用于用户的自定义数据）
 * @param   key                 需要获取的数据的Key值，为NSString类型
 * @result                      BOOL 类型，YES表示设置成功，NO表示设置失败
 */
+ (BOOL)removeObjectForKey:(NSString*)key {
    NSArray *arrPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *strCfgFile = [NSString stringWithFormat:@"%@/%@", [arrPaths objectAtIndex:0], FILE_USERCUSTOMDATA];
    NSMutableDictionary *dicCfg = nil;
    NSFileManager *fMgr = [NSFileManager defaultManager];
    if ([fMgr fileExistsAtPath:strCfgFile]) {
        dicCfg = [[NSMutableDictionary alloc] initWithContentsOfFile:strCfgFile];
    }
    else {
        dicCfg = [[NSMutableDictionary alloc] initWithCapacity:0];
    }
    [dicCfg removeObjectForKey:key];
    BOOL bRet = [dicCfg writeToFile:strCfgFile atomically:YES];
    return bRet;
}


@end

